Previous: atoms, Up: Sexp Types

Composite Sexp Widgets

The syntax for the composite widget construct is:

     type ::= (construct [keyword argument]...  component...)

where each component must be a widget type. Each component widget will be displayed in the buffer, and will be editable by the user.

— Widget: cons

The value of a cons widget must be a cons-cell whose car and cdr have two specified types. It uses this syntax:

          type ::= (cons [keyword argument]...  car-type cdr-type)
— Widget: choice

The value matched by a choice widget must have one of a fixed set of types. The widget's syntax is as follows:

          type ::= (choice [keyword argument]...  type ... )

The value of a choice widget can be anything that matches any of the types.

— Widget: list

The value of a list widget must be a list whose element types match the specified component types:

          type ::= (list [keyword argument]...  component-type...)

Thus, (list string number) matches lists of two elements, the first being a string and the second being a number.

— Widget: vector

The vector widget is like the list widget but matches vectors instead of lists. Thus, (vector string number) matches vectors of two elements, the first being a string and the second being a number.

The above suffice for specifying fixed size lists and vectors. To get variable length lists and vectors, you can use a choice, set, or repeat widget together with the :inline keyword. If any component of a composite widget has the :inline keyword set, its value must be a list which will then be spliced into the composite. For example, to specify a list whose first element must be a file name, and whose remaining elements should either be the symbol t or two strings (file names), you can use the following widget specification:

     (list file
           (choice (const t)
                   (list :inline t
                         :value ("foo" "bar")
                         string string)))

The value of a widget of this type will either have the form (file t) or (file string string).

This concept of :inline may be hard to understand. It was certainly hard to implement, so instead of confusing you more by trying to explain it here, I'll just suggest you meditate over it for a while.

— Widget: set

Specifies a type whose values are the lists whose elements all belong to a given set. The order of elements of the list is not significant. Here's the syntax:

          type ::= (set [keyword argument]...  permitted-element ... )

Use const to specify each permitted element, like this: (set (const a) (const b)).

— Widget: repeat

Specifies a list of any number of elements that fit a certain type.

          type ::= (repeat [keyword argument]...  type)